class ConfigParser {
    constructor(defaultConfig = {}) {
        // 默认配置（应用级全局默认值）
        this.defaultConfig = {
            deviceIndex: -1,
            logLevel: 'info',
            port: 8989,
            nonInteractive: false,
            onlydummy: false,
            ...defaultConfig // 允许外部传入自定义默认值
        };

        // 解析后的最终配置
        this.config = { ...this.defaultConfig };

        // 立即解析配置
        this.parseEnv();
        this.parseCliArgs();
        this.validateConfig();
    }

    /**
     * 解析环境变量
     */
    parseEnv() {
        const envMappings = {
            // 环境变量名 -> 配置键名
            DEVICE_INDEX: 'deviceIndex',
            LOG_LEVEL: 'logLevel',
            PORT: 'port',
            SERVER_PORT: 'port', // 兼容旧的环境变量名
            NON_INTERACTIVE: 'nonInteractive',
            ONLYDUMMY: 'onlydummy'
        };

        // 从环境变量提取配置
        Object.entries(envMappings).forEach(([envKey, configKey]) => {
            if (process.env[envKey] !== undefined) {
                this.config[configKey] = this.parseValue(configKey, process.env[envKey]);
            }
        });
    }

    /**
     * 解析命令行参数
     */
    parseCliArgs() {
        const cliMappings = {
            // 命令行参数 -> 配置键名
            '--device': 'deviceIndex',
            '--log': 'logLevel',
            '--port': 'port',
            '--non-interactive': 'nonInteractive',
            '--onlydummy': 'onlydummy'
        };

        // 从命令行参数提取配置（优先级高于环境变量）
        process.argv.slice(2).forEach(arg => {
            // 处理键值对参数（如--device=1）
            if (arg.includes('=')) {
                const [key, value] = arg.split('=');
                const configKey = cliMappings[key];
                if (configKey) {
                    this.config[configKey] = this.parseValue(configKey, value);
                }
            }
            // 处理开关参数（如--non-interactive）
            else {
                const configKey = cliMappings[arg];
                if (configKey) {
                    this.config[configKey] = true;
                }
            }
        });
    }

    /**
     * 根据配置键解析值（类型转换）
     */
    parseValue(configKey, value) {
        switch (configKey) {
            case 'deviceIndex':
                return Number(value);
            case 'port':
                return Number(value); // 转换为数字
            case 'nonInteractive':
                return value === 'true' || value === true; // 转换为布尔值
            case 'onlydummy':
                return value === 'true' || value === true; // 转换为布尔值
            default:
                return value; // 其他保持字符串
        }
    }

    /**
     * 验证配置合法性
     */
    validateConfig() {
        // 验证端口范围
        if (this.config.port < 1 || this.config.port > 65535) {
            this.config.port = this.defaultConfig.port;
            console.log(`⚠️ 无效端口，使用默认端口: ${this.defaultConfig.port}`);
        }

        // 验证日志级别
        if (!['info', 'debug', 'warn', 'error'].includes(this.config.logLevel)) {
            this.config.logLevel = this.defaultConfig.logLevel;
            console.log(`⚠️ 无效日志级别，使用默认级别: ${this.defaultConfig.logLevel}`);
        }
    }

    /**
     * 获取配置（支持部分获取或全部获取）
     * @param {string} key 可选，配置键名
     * @returns {any|Object} 单个配置值或全部配置
     */
    get(key) {
        return key ? this.config[key] : { ...this.config };
    }

    /**
     * 合并外部配置（用于模块级自定义配置）
     * @param {Object} customConfig 自定义配置
     * @returns {Object} 合并后的配置
     */
    merge(customConfig) {
        return { ...this.config, ...customConfig };
    }
}

module.exports = ConfigParser;
